/**
 * LRU 缓存机制， 最近最新使用， 也就是淘汰最早使用的，
 * 比如一个浏览器， 浏览了100个网页， 那么， 假如需要缓存80个网页， 怎么做呢
 *
 */

class LRU {
    constructor(opacity) {
        // 设置我们要缓存的容器大小
        this.opacity = opacity;
        this.list = []
    }

    put(key, value) {
        // 如果队列中有该缓存， 将原来位置删掉， 将其放置到最新的位置
        if(this.isNodeInList(key)){
            this.remove(key)
            this.list.unshift({key:value})
        }else {
            if(this.isFull()){
                this.list.pop()
                this.list.unshift({key:value})
            }
        }
    }

    // 获取指定的节点， 并将该节点放到最新的位置， 因为这里已经被使用过了， 所以， 需要更新到最前面。
    // 其他的好像都是和cache一样进行普通的处理， 但是这里需要的是，使用过后， 需要进行更新操作。
    get(key){
        if(this.isNodeInList(key)) {
            const node = this.remove(key)
            this.list.unshift(key, node)
        }else {
            return  -1;
        }
    }

    // 删除队列中的指定节点
    remove(key) {
        for(let i=0; i<this.list.length; i++) {
            if(this.list[i].key === key) {
                const node = this.list.splice(i, 1)
                // 删除的哪一个， 返回删除的key
                return node.key
            }
        }
    }

    // 判断目标节点是否在队列中
    isNodeInList(key) {
        for(let item of this.list) {
            if(item.key === key) {
                return item
            }
        }
        return false;
    }
    // 判断队列是否满了
    isFull(){
        return this.list.length === this.opacity
    }
}


class LRUV2 {
    constructor(opacity) {
        this.opcacity = opacity
        this.list = []
    }
    put(key,value) {
        if(this.isNodeInList(key)) {
            this.remove(key)
            this.list.unshift({key:value})
        }else {
            this.list.unshift({key:value})
        }
    }
    get(key) {
        if(!this.isNodeInList(key)) return null
        for(let item of this.list) {
            if(item.key === key) {
                // 在原有位置删除node
                const node = this.remove(key)
                // 将删除后的node入队
                this.list.unshift(node)
                // 最后返回这个node， 就是最近使用的一个
                return  node;
            }
        }
    }
    remove(key) {
        if(this.isNodeInList(key)) {
            for(let i=0; i<this.list.length; i++) {
                if(this.list[i].key === key) {
                    const node = this.list[i]
                    this.list.splice(i, 1)
                    return node
                }
            }
        }else {
            return  -1;
        }
    }
    isNodeInList(key){
        for(let i =0; i<this.list.length; i++) {
            if(this.list[i].key=== key) {
                return true
            }
        }
        return false;
    }
    isFull(){
        return this.list.length === this.opcacity;
    }
}



class LUR{
    constructor(maxListener) {
        this.maxListener = maxListener
        this.events = []
    }

    put(key, value){
        if(this.isNodeInList(key)){
            this.remove(key)
            this.events.unshift({key, value})
        }else {
            this.events.unshift({key, value})
        }
    }

    get(key){
        if(this.isNodeInList(key)){
            this.remove(key)
            this.events.unshift({key, value})
        }else {
            console.log('该方法不存在哦～')
        }

    }

    remove(key){
        if(this.isNodeInList(key)){
            this.events.forEach((item,index) => {
                item.key === key && this.events.splice(index, 1)
            })
        }else {
            console.log('该方法不存在哦！')
        }
    }

    isFull(){
        return this.events.length === this.maxListener
    }

    isNodeInList(key){
        this.events.map(item => {
            return item.key === key
        })
    }
}
